/**
 * uni-app 兼容性工具函数
 * 用于处理不同平台间的 API 差异
 */

/**
 * 导航到指定页面
 * @param {string} url - 页面路径
 * @param {object} options - 导航选项
 */
export function navigateTo(url, options = {}) {
  return new Promise((resolve, reject) => {
    uni.navigateTo({
      url,
      ...options,
      success: resolve,
      fail: reject
    });
  });
}

/**
 * 重定向到指定页面
 * @param {string} url - 页面路径
 * @param {object} options - 导航选项
 */
export function redirectTo(url, options = {}) {
  return new Promise((resolve, reject) => {
    uni.redirectTo({
      url,
      ...options,
      success: resolve,
      fail: reject
    });
  });
}

/**
 * 返回上一页
 * @param {object} options - 导航选项
 */
export function navigateBack(options = {}) {
  return new Promise((resolve, reject) => {
    uni.navigateBack({
      ...options,
      success: resolve,
      fail: reject
    });
  });
}

/**
 * 切换到 tabBar 页面
 * @param {string} url - 页面路径
 * @param {object} options - 导航选项
 */
export function switchTab(url, options = {}) {
  return new Promise((resolve, reject) => {
    uni.switchTab({
      url,
      ...options,
      success: resolve,
      fail: reject
    });
  });
}

/**
 * 获取当前页面参数
 * @returns {object} 页面参数
 */
export function getPageParams() {
  const pages = getCurrentPages();
  const currentPage = pages[pages.length - 1];
  return currentPage.options || {};
}

/**
 * 显示确认对话框
 * @param {string} title - 标题
 * @param {string} content - 内容
 * @param {object} options - 选项
 * @returns {Promise} 用户选择结果
 */
export function showConfirm(title, content, options = {}) {
  return new Promise((resolve, reject) => {
    uni.showModal({
      title,
      content,
      showCancel: true,
      ...options,
      success: (res) => {
        if (res.confirm) {
          resolve(true);
        } else {
          resolve(false);
        }
      },
      fail: reject
    });
  });
}

/**
 * 显示提示信息
 * @param {string} title - 提示内容
 * @param {string} icon - 图标类型
 * @param {number} duration - 显示时长
 */
export function showToast(title, icon = 'none', duration = 2000) {
  uni.showToast({
    title,
    icon,
    duration
  });
}

/**
 * 显示加载提示
 * @param {string} title - 提示内容
 * @param {boolean} mask - 是否显示透明蒙层
 */
export function showLoading(title = '加载中...', mask = true) {
  uni.showLoading({
    title,
    mask
  });
}

/**
 * 隐藏加载提示
 */
export function hideLoading() {
  uni.hideLoading();
}

/**
 * 获取存储数据
 * @param {string} key - 键名
 * @param {any} defaultValue - 默认值
 * @returns {any} 存储的数据
 */
export function getStorage(key, defaultValue = null) {
  try {
    const value = uni.getStorageSync(key);
    return value !== '' ? value : defaultValue;
  } catch (error) {
    console.error('获取存储数据失败:', error);
    return defaultValue;
  }
}

/**
 * 设置存储数据
 * @param {string} key - 键名
 * @param {any} value - 值
 */
export function setStorage(key, value) {
  try {
    uni.setStorageSync(key, value);
  } catch (error) {
    console.error('设置存储数据失败:', error);
  }
}

/**
 * 移除存储数据
 * @param {string} key - 键名
 */
export function removeStorage(key) {
  try {
    uni.removeStorageSync(key);
  } catch (error) {
    console.error('移除存储数据失败:', error);
  }
}

/**
 * 清除所有存储数据
 */
export function clearStorage() {
  try {
    uni.clearStorageSync();
  } catch (error) {
    console.error('清除存储数据失败:', error);
  }
}

/**
 * 创建 WebSocket 连接
 * @param {string} url - WebSocket URL
 * @param {object} options - 连接选项
 * @returns {object} WebSocket 连接对象
 */
export function createWebSocket(url, options = {}) {
  const {
    onOpen,
    onMessage,
    onClose,
    onError
  } = options;

  // 使用 uni-app 的 connectSocket API
  const socketTask = uni.connectSocket({
    url,
    success: () => {
      console.log('WebSocket连接请求已发送');
    },
    fail: (error) => {
      console.error('WebSocket连接失败:', error);
      if (onError) onError(error);
    }
  });

  // 监听连接打开
  uni.onSocketOpen(() => {
    console.log('WebSocket连接已建立');
    if (onOpen) onOpen();
  });

  // 监听消息
  uni.onSocketMessage((event) => {
    try {
      const message = JSON.parse(event.data);
      if (onMessage) onMessage(message);
    } catch (error) {
      console.error('解析WebSocket消息失败:', error);
    }
  });

  // 监听连接关闭
  uni.onSocketClose((event) => {
    console.log('WebSocket连接已关闭:', event.code, event.reason);
    if (onClose) onClose(event);
  });

  // 监听连接错误
  uni.onSocketError((error) => {
    console.error('WebSocket连接错误:', error);
    if (onError) onError(error);
  });

  return {
    send: (data) => {
      uni.sendSocketMessage({
        data: typeof data === 'string' ? data : JSON.stringify(data),
        success: () => {
          console.log('消息发送成功');
        },
        fail: (error) => {
          console.error('消息发送失败:', error);
        }
      });
    },
    close: () => {
      uni.closeSocket({
        success: () => {
          console.log('WebSocket连接已关闭');
        },
        fail: (error) => {
          console.error('关闭WebSocket连接失败:', error);
        }
      });
    }
  };
}

/**
 * 创建 Canvas 上下文
 * @param {string} canvasId - Canvas ID
 * @returns {object} Canvas 上下文
 */
export function createCanvasContext(canvasId) {
  return uni.createCanvasContext(canvasId);
}

/**
 * 获取系统信息
 * @returns {object} 系统信息
 */
export function getSystemInfo() {
  return uni.getSystemInfoSync();
}

/**
 * 获取网络类型
 * @returns {Promise} 网络类型
 */
export function getNetworkType() {
  return new Promise((resolve, reject) => {
    uni.getNetworkType({
      success: resolve,
      fail: reject
    });
  });
}

/**
 * 检查网络连接状态
 * @returns {Promise} 网络连接状态
 */
export function checkNetworkStatus() {
  return new Promise((resolve, reject) => {
    uni.getNetworkType({
      success: (res) => {
        resolve(res.networkType !== 'none');
      },
      fail: reject
    });
  });
}

/**
 * 防抖函数
 * @param {Function} func - 要防抖的函数
 * @param {number} wait - 等待时间
 * @returns {Function} 防抖后的函数
 */
export function debounce(func, wait) {
  let timeout;
  return function executedFunction(...args) {
    const later = () => {
      clearTimeout(timeout);
      func(...args);
    };
    clearTimeout(timeout);
    timeout = setTimeout(later, wait);
  };
}

/**
 * 节流函数
 * @param {Function} func - 要节流的函数
 * @param {number} limit - 限制时间
 * @returns {Function} 节流后的函数
 */
export function throttle(func, limit) {
  let inThrottle;
  return function executedFunction(...args) {
    if (!inThrottle) {
      func.apply(this, args);
      inThrottle = true;
      setTimeout(() => inThrottle = false, limit);
    }
  };
}

/**
 * 格式化时间
 * @param {Date|number} date - 日期对象或时间戳
 * @param {string} format - 格式化字符串
 * @returns {string} 格式化后的时间字符串
 */
export function formatTime(date, format = 'YYYY-MM-DD HH:mm:ss') {
  const d = new Date(date);
  const year = d.getFullYear();
  const month = String(d.getMonth() + 1).padStart(2, '0');
  const day = String(d.getDate()).padStart(2, '0');
  const hours = String(d.getHours()).padStart(2, '0');
  const minutes = String(d.getMinutes()).padStart(2, '0');
  const seconds = String(d.getSeconds()).padStart(2, '0');

  return format
    .replace('YYYY', year)
    .replace('MM', month)
    .replace('DD', day)
    .replace('HH', hours)
    .replace('mm', minutes)
    .replace('ss', seconds);
}

/**
 * 生成唯一ID
 * @returns {string} 唯一ID
 */
export function generateId() {
  return Date.now().toString(36) + Math.random().toString(36).substr(2);
}

/**
 * 深拷贝对象
 * @param {any} obj - 要拷贝的对象
 * @returns {any} 拷贝后的对象
 */
export function deepClone(obj) {
  if (obj === null || typeof obj !== 'object') return obj;
  if (obj instanceof Date) return new Date(obj.getTime());
  if (obj instanceof Array) return obj.map(item => deepClone(item));
  if (typeof obj === 'object') {
    const clonedObj = {};
    for (const key in obj) {
      if (obj.hasOwnProperty(key)) {
        clonedObj[key] = deepClone(obj[key]);
      }
    }
    return clonedObj;
  }
} 